函数自学引导
第1关：整数幂运算
#分行输入两个整数m，n，计算m的n次幂并输出结果
m=eval(input())
n=eval(input())
result=1
for i in range(n):
    result=result*m
print(result)

第2关：自定义整数幂运算无参函数
def mi(m,n):
    result=1
    for i in range(n):
        result=result*m
   
    """此函数用于计算整数x的n次幂，无参数，返回幂运算结果，一个整数。
    函数中需要用程序语句接受用户输入的整数的底数x和指数n，计算x的n次幂，
    返回计算结果"""
    # 对齐此位置写函数体语句和返回值语句
    return result


# 将函数名作为输出语句的参数，在下一行补充调用函数并输出函数运算结果的语句
m=eval(input())
n=eval(input())
print(mi(m,n))

第3关：定义整数幂运算有参函数
def mi(m,n):
    result=1
    for i in range(n):
        result=result*m
   
    """此函数用于计算整数x的n次幂，无参数，返回幂运算结果，一个整数。
    函数中需要用程序语句接受用户输入的整数的底数x和指数n，计算x的n次幂，
    返回计算结果"""
    # 对齐此位置写函数体语句和返回值语句
    return result


# 将函数名作为输出语句的参数，在下一行补充调用函数并输出函数运算结果的语句
m=eval(input())
n=eval(input())
print(mi(m,n))

第4关：定义默认计算x的10次幂的幂运算函数
def user_pow(m,n=10):
    """接受两个整数参数，依次表示底数和幂，计算整数x的n次幂，返回幂运算结果。
    当函数调用时，若只传入一个参数，则值传给x，n使用默认值，返回x的10次幂"""
    # 对齐此位置写函数体语句和返回值语句
    result=1
    for i in range(n):
        result=result*m
    
    return result




# 分别输入两个整数，依次表示底和幂
number = int(input())       # 输入底数
m = int(input())            # 输入指数
# 调用函数并输出函数运算结果的语句
print(user_pow(number, m))  # 调用函数，传入2个参数
print(user_pow(number))     # 调用函数，只传入一个参数

第5关：关键字参数调用整数幂运算的函数
def user_pow(n, x):
    """接受两个整数参数，依次表示底数和幂，计算整数x的n次幂，返回幂运算结果。"""
    pow_of_x = 1  # 累乘初值，1乘任何数结果不变
    for i in range(n):  # i取值0，1，2，3，...，n-1，共循环n次
        pow_of_x = pow_of_x * x  # 每循环一次乘上一个5，循环n次，结果是计算5的n次幂
    return pow_of_x  # 返回函数的运算结果到函数调用处


# 补充2条语句分别输入两个整数，依次表示底和幂
number = int(input())       # 输入底数
m = int(input())            # 输入指数
# 调用函数时用关键字传递参数值
# 调用函数，底数在前，指数在后，在下面补充一条调用函数并输出结果的语句
print(user_pow(x=number, n=m))  # 调用函数，传入2个参数，不需要考虑顺序
print(user_pow(n=m, x=number))  # 调用函数，传入2个参数，不需要考虑顺序
# 调用函数，指数在前，底数在后，在下面补充一条调用函数并输出结果的语句

第6关：应用幂函数进行运算
# 定义一个整数幂函数，接受两个整数参数，依次表示底数和幂，计算整数x的n次幂，返回幂运算结果
# 此代码仅用于学习函数定义和返回值，要求用循环实现幂函数的计算
def power(x, n):
    """计算 x 的 n 次方"""
    return x ** n

def compute_f(x, n):
    """计算 f 的值"""
    total = 0
    for i in range(1, n + 1):
        total += i / power(x, i)
    return total

# 用户输入
x = float(input())
n = int(input())

# 计算 f 并输出结果
result = compute_f(x, n)

# 格式化输出
if result.is_integer():
    print(f"{result:.1f}")
else:
    print(f"{result:.3f}")

哥德巴赫猜想
def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False"""
    if n < 2:
        return False  # 0、1、负数以及偶数都不是素数
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:  # 能被2到其n-1之间的数整除的数不是素数
            return False
    else:
        return True  # for循环正常结束，未遇到return的数是素数
 
    
def goldbach_conjecture(num):
    """ 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
    当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
    有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
    参数为奇数或小于4时，输出'Data error!'
    """
    if num % 2 == 0 and num >= 4:                 # 只判定偶数
        for i in range(num // 2+1):    # 超过num // 2的组合为重复组合
            if is_prime(i) and is_prime(num - i):
                print(f"{num}={i}+{num-i}")
    else:
        print('Data error!')
 
if __name__ == '__main__':
    positive_even = int(input())        # 输入一个正数
    goldbach_conjecture(positive_even)

二分法求平方根B
import math

def sqrt_binary(n, precision):
    if n < 0:
        raise ValueError("Input must be a non-negative real number.")
    
    low, high = 0, n + 0.25
    while True:
        mid = (low + high) / 2
        mid_squared = mid * mid
        
        if abs(mid_squared - n) <= precision:
            return round(mid, 8)
        
        if mid_squared < n:
            low = mid
        else:
            high = mid

# 用户输入
user_input = input()
n, precision = map(float, user_input.split(','))

# 计算平方根并输出结果
binary_result = sqrt_binary(n, precision)
math_result = round(math.sqrt(n), 8)

print(f"{binary_result:.8f}")
print(f"{math_result:.8f}")

本月天数
def is_leap(year):
    # 判断year是否为闰年，闰年返回True，非闰年返回False
    if (year % 100 != 0 and year % 4 == 0) or year % 400 == 0:
        return True
    else:
        return False
 
 
def days_of_month(year,month):
    # 根据输入的年月日，返回该月的天数
    tian = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    if is_leap(year):
        tian[1] = 29
    print(tian[month-1])
 
str = input()
year = int(str[0:4])
month = int(str[4:6])
days_of_month(year,month)
 
打印温度转换速查表
def F2C(f):
        c=5*(f-32)/9
        return c
 
 
left,right=map(int,input().split(','))
if left>right:
    print('error')
else:
    for f in range(left,right+1,2):
        print("{} : {:.2f}".format(f,F2C(f)))

模拟战狼一之入侵网络(project)
第1关：输出斐波那契数列的前n项
n=int(input())
list=[]
for m in range(0,n):
    if m==0:
        list.append(0)
    elif m==1:
        list.append(1)
    else:
        list.append(list[m-1]+list[m-2])
for i in range(len(list)):
    print(list[i],end=' ')

第2关：找 m 到 n 之间的所有素数
lower = int(input())
upper = int(input())
 
for num in range(lower,upper + 1):
    # 素数大于 1
    if num > 1:
        for i in range(2,num):
            if (num % i) == 0:
                break
        else:
            print(num,end=' ')

第3关：找 100 到 999 之间的所有水仙花数
for i in range(100,1000):
    bai=i//100
    shi=i%100//10
    ge=i%10
    if i==bai**3+shi**3+ge**3:
        print(i,end=' ')

第4关：输入一个整数并找出其所有因数
def find_factors(n):
    factors = []
    for i in range(1, n + 1):
        if n % i == 0:
            factors.append(i)
    return factors

# 用户输入
n = int(input())

# 计算因子并输出结果
factors = find_factors(n)
print(" ".join(map(str, factors)))

第5关：根据键盘输入的分数评出五分制等级
x=input()
x=int(x)
if 0<=x<60:     
    print("E")
elif x>=60:
    if x<70:
        print("D")
    elif x<80:
        print("C")
    elif x<90:
        print("B")
    else:
        print("A")

第6关：根据输入判断是星期几
def get_weekday_first_letter(first_letter, second_letter=None):
    first_letter = first_letter.lower()
    if first_letter == 'm':
        return "Monday"
    elif first_letter == 't':
        if second_letter == 'e':
            return "Tuesday"
        elif second_letter == 'h' or second_letter == 'r' :
            return "Thursday"
        return "无法匹配"
    elif first_letter == 'w':
        return "Wednesday"
    elif first_letter == 'f':
        return "Friday"
    elif first_letter == 's':
        if second_letter == 't' or second_letter == 'r':
            return "Saturday"
        elif second_letter == 'n':
            return "Sunday"
        return "无法匹配"
    else:
        return "无法匹配"
 
def main():
    first_letter = input().lower()
    if first_letter == 't' or first_letter == 's':
        second_letter = input().lower()
        result = get_weekday_first_letter(first_letter, second_letter)
    else:
        result = get_weekday_first_letter(first_letter)
    print(result)
 
if __name__ == "__main__":
    main()


二分法求平方根B
import math  
  
def sqrt_binary(n, precision):
    low, high = 0, n + 0.25  
    mid = (low + high) / 2  
      
    while abs(mid * mid - n) > precision:  
        if mid * mid < n:  
            low = mid  
        else:  
            high = mid  
        mid = (low + high) / 2  
      
    return mid
input_str = input().strip()  
n, precision_str = input_str.split(',')  
n = float(n)  
precision = float(precision_str)
binary_sqrt = sqrt_binary(n, precision)  
math_sqrt = math.sqrt(n)  

print(f"{binary_sqrt:.8f}")  
print(f"{math_sqrt:.8f}")